.TH std::fixed,std::scientific,std::hexfloat,std::defaultfloat 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::fixed,std::scientific,std::hexfloat,std::defaultfloat \- std::fixed,std::scientific,std::hexfloat,std::defaultfloat

.SH Synopsis
   Defined in header <ios>
   std::ios_base& fixed( std::ios_base& str );        \fB(1)\fP
   std::ios_base& scientific( std::ios_base& str );   \fB(2)\fP
   std::ios_base& hexfloat( std::ios_base& str );     \fB(3)\fP \fI(since C++11)\fP
   std::ios_base& defaultfloat( std::ios_base& str ); \fB(4)\fP \fI(since C++11)\fP

   Modifies the default formatting for floating-point output.

   1) Sets the floatfield of the stream str to fixed as if by calling
   str.setf(std::ios_base::fixed, std::ios_base::floatfield).
   2) Sets the floatfield of the stream str to scientific as if by calling
   str.setf(std::ios_base::scientific, std::ios_base::floatfield).
   3) Sets the floatfield of the stream str to fixed and scientific simultaneously as
   if by calling str.setf(std::ios_base::fixed | std::ios_base::scientific,
   std::ios_base::floatfield). This enables hexadecimal floating-point formatting.
   4) Sets the floatfield of the stream str to zero, as if by calling
   str.unsetf(std::ios_base::floatfield). This enables the default floating-point
   formatting, which is different from fixed and scientific.

   This is an I/O manipulator, it may be called with an expression such as out <<
   std::fixed for any out of type std::basic_ostream (or with an expression such as in
   >> std::scientific for any in of type std::basic_istream).

.SH Parameters

   str - reference to I/O stream

.SH Return value

   str (reference to the stream after manipulation).

.SH Notes

   Hexadecimal floating-point formatting ignores the stream precision specification, as
   required by the specification of std::num_put::do_put.

   These manipulators do not affect floating-point parsing.

.SH Example


// Run this code

 #include <iomanip>
 #include <iostream>
 #include <sstream>

 enum class cap { title, middle, end };

 void print(const char* text, double num, cap c)
 {
     if (c == cap::title)
         std::cout <<
             "┌──────────┬────────────┬──────────────────────────┐\\n"
             "│  number  │   iomanip  │      representation      │\\n"
             "├──────────┼────────────┼──────────────────────────┤\\n";
     std::cout << std::left
          << "│ " << std::setw(8) << text <<      " │ fixed      │ "
          << std::setw(24) << std::fixed  << num <<            " │\\n"
          << "│ " << std::setw(8) << text <<      " │ scientific │ "
          << std::setw(24) << std::scientific << num <<        " │\\n"
          << "│ " << std::setw(8) << text <<      " │ hexfloat   │ "
          << std::setw(24) << std::hexfloat << num <<          " │\\n"
          << "│ " << std::setw(8) << text <<      " │ default    │ "
          << std::setw(24) << std::defaultfloat << num <<      " │\\n";
     std::cout << (c != cap::end ?
             "├──────────┼────────────┼──────────────────────────┤\\n" :
             "└──────────┴────────────┴──────────────────────────┘\\n");
 }

 int main()
 {
     print("0.0", 0.0, cap::title);
     print("0.01", 0.01, cap::middle);
     print("0.00001", 0.00001, cap::end);

     // Note; choose clang for correct output
     double f;
     std::istringstream("0x1.8p+0") >> f;
     std::cout << "Parsing 0x1.8p+0 gives " << f << '\\n';

     std::istringstream("0x1P-1022") >> f;
     std::cout << "Parsing 0x1P-1022 gives " << f << '\\n';
 }

.SH Output:

 ┌──────────┬────────────┬──────────────────────────┐
 │  number  │   iomanip  │      representation      │
 ├──────────┼────────────┼──────────────────────────┤
 │ 0.0      │ fixed      │ 0.000000                 │
 │ 0.0      │ scientific │ 0.000000e+00             │
 │ 0.0      │ hexfloat   │ 0x0p+0                   │
 │ 0.0      │ default    │ 0                        │
 ├──────────┼────────────┼──────────────────────────┤
 │ 0.01     │ fixed      │ 0.010000                 │
 │ 0.01     │ scientific │ 1.000000e-02             │
 │ 0.01     │ hexfloat   │ 0x1.47ae147ae147bp-7     │
 │ 0.01     │ default    │ 0.01                     │
 ├──────────┼────────────┼──────────────────────────┤
 │ 0.00001  │ fixed      │ 0.000010                 │
 │ 0.00001  │ scientific │ 1.000000e-05             │
 │ 0.00001  │ hexfloat   │ 0x1.4f8b588e368f1p-17    │
 │ 0.00001  │ default    │ 1e-05                    │
 └──────────┴────────────┴──────────────────────────┘
 Parsing 0x1.8p+0 gives 1.5
 Parsing 0x1P-1022 gives 2.22507e-308

.SH See also

   setprecision changes floating-point precision
                \fI(function)\fP
